home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / Libraries / VideoToolbox 94.11.17 / VideoToolboxSources / Assign.c next >
Encoding:
Text File  |  1994-11-16  |  57.7 KB  |  2,031 lines  |  [TEXT/KAHL]
  1. /*
  2. Assign.c
  3.  
  4. Assign is a portable runtime C interpreter that reads and executes any text
  5. "assignment" file that contains only C assignments and comments, e.g.
  6.     viewingDistance=57.0;    // inches
  7.     
  8. See Assign.note for documentation.
  9.  
  10. (It would be nice to add a flag for PrintAssignmentsToFile() that would request
  11. a read-after-write check, ala WriteLuminanceRecord in ReadLuminanceRecord.c.)
  12.  
  13. HISTORY
  14. 7/30/91 dgp    wrote it as "ReadAssignments.c".
  15. 8/4/91    dgp added new routines and renamed the old ones. Everything
  16.             seems to work, but has not been thoroughly tested.
  17. 8/5/91    dgp    MPW C 3.2 now compiles it without error messages. The MPW C macro processor,
  18.             contrary to Standard C, finds comment symbols inside strings and finds 
  19.             preprocessor directives even when # is not the first nonblank character.
  20. 8/24/91    dgp    Made compatible with THINK C 5.0.
  21.             Changed ReadAssignment file to return an error code instead of aborting
  22.             if it can't open the file.
  23. 8/26/91    dgp    Added SetVariable() and noted, in Assign.note, that the Variable array
  24.             is terminated by an element with its "type" field set to zero. (Thanks
  25.             to Evan Relkin for pointing out the omission.)
  26. 4/1/92    dgp    Tidied up Assign.note.
  27. 4/2/92    dgp Introduced ReadAssignmentBlock() and AssignmentLineWasBlank(). 
  28.             Deleted ReadAssignments().
  29. 4/5/92    dgp    ReadAssignmentFile() now closes the file before returning.
  30. 4/17/92    dgp    Expanded the explanation of flags, as requested by Evan Relkin.
  31. 5/14/92    dgp    Expanded the explanation of stringType, "".
  32. 8/4/92    dgp    Added PrintAnAssignment(), which prints out the value of a variable,
  33.             as an assignment statement, suitable for reading by the ReadAssignment
  34.             routines.
  35. 10/24/92 dgp Eliminated double spacing that occurred after //-style comment when 
  36.             assignEchoComment was requested.
  37. 3/4/93    dgp    changed the definition of emptyString slightly so that this file could be
  38.             compiled as a code resource.
  39. 5/24/93    dgp    Assignment lines may now be continued by putting a backslash at the end of
  40.             the line.
  41.             Strings may include literal linefeeds, rather than just "\n".
  42.             Printed string assignments translate linefeeds to "\n".
  43.             Skip unknown variables unless flags&assignReportUnknown is true.
  44. 5/27/93    dgp    Added "dim" field to Variable structure, and added support for
  45.             it in all the routines.
  46.             Added floatType.
  47.             Input line length is still limited to BUFFER_SIZE (presently 512) but
  48.             strings (broken up into lines of legal length and automatically 
  49.             concatenated during reading) can be of any length that will fit
  50.             in memory.
  51. 5/28/93    dgp    Added support for hex-encoded strings.
  52.             Created new bottleneck procedure ReadLine that does all the reading.
  53. 5/31/93    dgp    assignEchoAssignments now calls PrintAnAssignment. Removed "\n" from
  54.             PrintAnAssignment. Made all Print routines return assignment count,
  55.             which is now redefined as the number of array elements or scalars
  56.             that were assigned or printed. Now parse names so that
  57.             known and unknown identifiers are treated uniformly; these new
  58.             naming rules allow only simple C identifiers joined by "." and "->".
  59. 6/1/93    dgp    introduced assignNoPrintfExit flag that causes all routines to handle
  60.             errors discreetely, simply returning an error number to the caller.
  61. 6/2/93    dgp PrintAnAssignment now prints multiple assignments per 80 character line, 
  62.             adding as many continuation lines as necessary. Quoted strings (and hex
  63.             data strings) are now broken up into 80-character lines; continuation
  64.             lines are indented four spaces. Added comment field to Variable structure
  65.             and added support for it in PrintAnAssignment. Renamed all published
  66.             enum values to begin with "assign". Renamed this file "Assign.c". Added
  67.             UnequalVariables(). CheckAVariable checks that variable name is legal.
  68. 6/5/93    dgp    Removed all Macintosh dependencies, leaving pure Standard C plus a few
  69.             C++ style comments.
  70. 6/16/93    dgp    Removed prohibition: arrays of stringType are now ok.
  71.             InitializeAVariable now calls CheckAVariable with "flags" unmodified.
  72.             CheckAVariable now checks for any illegal suffix in name.
  73.             Unknown subscripted variables are now correctly reported as "UNKNOWN" 
  74.             rather than "OUT OF BOUNDS".
  75. 6/29/93    dgp    added shortDoubleType.
  76. 7/10/93    dgp    restored Standard C compatibility by using "short double" only if
  77.             SHORT_DOUBLE_OK, since Standard C doesn't allow that type.
  78. 7/19/93    dgp    noted that assign file should be opened in text mode, not binary mode, so that
  79.             \r characters will be translated properly.
  80. 7/29/93    dhb & dgp Found and fixed the newline problem that appears in the MATLAB
  81.             environment, as documented in Assign.note.
  82. 7/31/93    dgp    Added support for multidimensional arrays, with up to ASSIGN_DIMS
  83.             dimensions. Added SetVariableArray(), changed SetVariable() and
  84.             SetVariableFirstLast(), and deleted SetAVariableFirstLast().
  85. 8/2/93    dgp    Added dynamic allocation of ptrType arrays, based on scanning the current
  86.             gulp of the assign file.
  87. 8/12/93    dgp    Renamed "Variable" to "Description". Renamed most of the routines. 
  88.             The header file Assign92.h provides for backward compatibility.
  89. 8/21/93    dhb,dgp    For compatibility with MATLAB we avoid using int arguments in stdio 
  90.             calls because when MATLAB is true we'll be using MPW's stdio
  91.             library, and its int is 4 bytes whereas the THINK C int is 2 bytes.
  92.         dhb,jms    Changed "wa" in fopen in PrintAssignmentsToFile to "a".
  93.         dhb,jms,dgp Moved the NL and NEWLINE macros into VideoToolbox.h.
  94. 9/2/93    dgp    Expanded documentation of FreePtrVariables. Fixed minor bugs
  95.             in PrintAVariable for hex encoded Ptr variables so that dimensionality
  96.             of what was written is recovered when it's read.
  97. 9/7/93    dgp    Introduced STDIO_INT.
  98. 9/7/93    dhb,jms,dgp    Added OpenCalFileWrite, OpenCalFileRead, OpenCalFileReadAndCheck,
  99.             AppendDescriptions, CopyDescriptions, AllocateDescriptions,
  100.             FreeDescriptions, NumberOfDescriptions, NullDescription, and 
  101.             IsNullDescription.
  102. 9/9/93    dhb    Added ReadAssignmentStream, to read the rest of a file stream as a single
  103.             gulp.
  104. 9/11/93    dgp    rewrote ReadAssignmentFile to just open the file and call 
  105.             ReadAssignmentStream.
  106. 9/12/93    dhb    Changed STDIO_INT to PRINTF_INT, added inclusion of VideoToolbox
  107.             when MATLAB is on.
  108. 9/15/93    dgp    Moved documentation to Assign.note.
  109. 9/16/93    dgp    Merged Assign.h into VideoToolbox.h.
  110. 3/4/94    dgp    Increased number of float and double digits produced by PrintAnAssignment 
  111.             up to that specified in float.h. This should eliminate spurious failure
  112.             of the read-back checks.
  113.             Enhanced PrintQuotedString to correctly handle strings containing the double
  114.             quote character.
  115. 3/28/94    dgp Inserted space before comments (i.e. before "/*") and now pad the inside
  116.             of the comment delimiters with option-space instead of space for more 
  117.             pleasing word wrapping when the assignment file is viewed in that way.
  118. 6/16/94    dgp    Enhanced ParsingError to use PrintQuotedString to print the offending text
  119.             so that any spurious nonprinting characters will be revealed.
  120.             ParsingError now suppresses "\n" at end of offending string.
  121.             Enhanced PrintQuotedString to accept arbitrary open and close strings, 
  122.             typically just the traditional double-quote character.
  123. 6/17/94    dgp    Modified PrintQuotedString to print option-space "\312" directly, so
  124.             that the printout will be readable.
  125. 7/6/94    dgp    Replaced maximum linelength of 80 by a compile-time constant of 76, so
  126.             that assignment files can be emailed.
  127. 7/7/94    dgp    Added CopyDescribedVars.
  128. 7/11/94 dgp Fixed bug in ReadAssignmentStream and ReadAssignmentLine that garbled the
  129.             returned error value, if there was an error, by adding to it the number of
  130.             lines read.
  131. 7/16/94 dgp Found and fixed a memory leak in ReadAssignmentLine. GetName() called
  132.             malloc for dScratch->name, which wasn't being freed. This cost about
  133.             40 bytes for every variable. I fixed that. There still seems to be a
  134.             much smaller memory leak, which I couldn't quickly locate, and which
  135.             I can live with for the time being.
  136. 9/5/94    dgp    added support for reading of Metrowerks CodeWarrior C style of printing
  137.             NANs, e.g. NAN(021)
  138. 9/10/94    dgp    the variable "error" is now always declared int. (So it's safe to print with %d.)
  139. */
  140. #include "VideoToolbox.h"
  141. #include <assert.h>
  142. #include <ctype.h>
  143. #include <math.h>
  144. #include <stdarg.h>
  145. #include <stdio.h>
  146. #include <stdlib.h>
  147. #include <string.h>
  148. #define MAX_LINELENGTH 76
  149. /*
  150. IsNan and IsFinite--see VideoToolbox.h--should work on most Intel and Motorola
  151. processors. If IsNan and IsFinite don't work on your computer, don't fret. They
  152. are used solely by UnequalDescribedVarPair. A quick fix is to use the following
  153. definitions, the only bad effect of which will be that comparisons of NANs may
  154. appear spuriously unequal.
  155. */
  156. #ifndef IsFinite
  157.     #define IsNan(x) 0
  158.     #define IsFinite(x) 1
  159. #endif
  160. Description SetAVariable(short type,void *ptr,char *name,unsigned long dim
  161.     ,const char *comment);    /* old style */
  162.  
  163. /* the following are private, not intended for use outside this file */
  164. #define IsIntegral(type) ((type)>=charType&&(type)<=unsignedLongType || (type)>=charPtrType&&(type)<=unsignedLongPtrType)
  165. #define IsFloating(type) ((type)>=floatType&&(type)<=doubleType || (type)>=floatPtrType&&(type)<=doublePtrType)
  166. #define IsString(type) (type==stringType)
  167. #define IsPtr(type) ((type)>=charPtrType&&(type)<=doublePtrType)
  168. long CheckADescription(Description *d,const char *here,short flags);
  169. long CheckDescriptions(Description d[],const char *here,short flags);
  170. void FreeAPtrDescription(Description *d,short flags);
  171. void FreeAStringDescription(Description *d,short flags);
  172. char *GetName(char **sPtr,short flags);
  173. char *GetQuotedString(FILE *stream,char *lineBuffer,char *s,char **sPtr,short flags);
  174. long HexAssignment(FILE *stream,char *lineBuffer,char **sPtr,Description *d
  175.     ,int subscriptDims,long index,long *bytesPtr,short flags);
  176. char *NextToken(FILE *stream,char *lineBuffer,char *s,short flags);
  177. char *NextTokenInLine(FILE *stream,char *lineBuffer,char *s,short flags);
  178. char *NextTokenInThisOrNextLine(FILE *stream,char *lineBuffer,char *s,short flags);
  179. int ParseName(char **sPtr);
  180. void ParsingError(char *s,char *format,...);
  181. long PrintAnAssignmentOfElement(FILE *stream,Description *d,long index,short flags);
  182. void PrintQuotedString(FILE *stream,short *lineLengthPtr,const char *s
  183.     ,const char *openQuote,const char *closeQuote);
  184. char *ReadLine(char *lineBuffer,size_t bufferSize,FILE *stream,short flags);
  185. double strtodN(char *s,char **sPtr);
  186. long strtolN(char *s,char **sPtr,short flags);
  187. unsigned long strtoulN(char *s,char **sPtr,short flags);
  188. char strtoc(char *s,char **sPtr);
  189. #define streq2(s1,s2) (strncmp(s1,s2,strlen(s2))==0)
  190. #define streq(s1,s2) (strcmp(s1,s2)==0)
  191. long Dims(Description *d);
  192. char *ElementName(char *s,Description *d,long index);
  193. void *ElementPtr(Description *d,long index);
  194. long Elements(Description *d);
  195. void ElementSubscript(Description *d,long index,long sub[ASSIGN_DIMS]);
  196. long ElementIndex(Description *d,long sub[ASSIGN_DIMS]);
  197. int GetDimensions(Description *d,int subscriptDims,long subscript[ASSIGN_DIMS],short flags);
  198. int AllocateDescribedPtrVars(Description description[],const char *here,short flags);
  199. #ifndef TRUE
  200.     #define FALSE    0
  201.     #define TRUE    1
  202. #endif
  203. #define TOLERANCE    1e-6    /* fractional difference between two "equal" floats */
  204. #define BUFFER_SIZE 512
  205. #define ECHO_ASSIGNMENTS    (flags&assignEchoAssignments && !(flags&assignScan))
  206. #define ECHO_COMMENTS        (flags&assignEchoComments && !(flags&assignScan))
  207. #define ECHO_FILE            (flags&assignEchoFile && !(flags&assignScan))
  208. #define PRINTF_EXIT            !(flags&assignNoPrintfExit)
  209.  
  210. static int lineWasBlank=1;    /* used in ReadAssignmentLine(),    */
  211.             /* NextTokenInThisOrNextLine(), and AssignmentLineWasBlank().*/
  212. short typeSize[]={0
  213.     ,sizeof(char),sizeof(unsigned char)
  214.     ,sizeof(short),sizeof(unsigned short)
  215.     ,sizeof(long),sizeof(unsigned long)
  216.     ,sizeof(float)
  217.     #if SHORT_DOUBLE_OK
  218.         ,sizeof(short double)
  219.     #endif
  220.     ,sizeof(double)
  221.     ,sizeof(char),sizeof(unsigned char)
  222.     ,sizeof(short),sizeof(unsigned short)
  223.     ,sizeof(long),sizeof(unsigned long)
  224.     ,sizeof(float)
  225.     #if SHORT_DOUBLE_OK
  226.         ,sizeof(short double)
  227.     #endif
  228.     ,sizeof(double)
  229.     ,sizeof(char *)
  230.     ,0
  231. };
  232. char typeName[][20]={"none"
  233.     ,"char","unsigned char","short","unsigned short"
  234.     ,"long","unsigned long","float"
  235.     #if SHORT_DOUBLE_OK
  236.         ,"short double"
  237.     #endif
  238.     ,"double"
  239.     ,"char *","unsigned char *","short *","unsigned short *"
  240.     ,"long *","unsigned long *","float *"
  241.     #if SHORT_DOUBLE_OK
  242.         ,"short double *"
  243.     #endif
  244.     ,"double *"
  245.     ,"string"
  246.     ,"unknown"
  247. };
  248. enum{assignNeedMore=0x4000,assignAlreadyChecked=0x2000
  249.     ,assignScan=0x100,assignLocalCall=0x200
  250. };/*flags used only in this file*/
  251.  
  252. /*
  253. ROUTINE: OpenCalFileReadAndCheck
  254. PURPOSE:
  255.     Open up a calibration file for reading.
  256.     
  257.     If the file exists in the current directory, it is used.
  258.     If not, then if it exists in the preferences folder, it used.
  259. */
  260.  
  261. FILE *OpenCalFileReadAndCheck(char *filename)
  262. {
  263.     FILE *stream;
  264.     
  265.     stream = OpenCalFileRead(filename);
  266.     if (stream == NULL)
  267.         PrintfExit("OpenCalFileReadAndCheck: cannot open file \"%s\"",filename);
  268.     return(stream);    
  269. }
  270.  
  271. /*
  272. ROUTINE: OpenCalFileRead
  273. PURPOSE:
  274.     Open up a calibration file for reading.  Don't abort on error.
  275.     
  276.     If the file exists in the current directory, it is used.
  277.     If not, then if it exists in the preferences folder, it used.
  278. */
  279.  
  280. FILE *OpenCalFileRead(char *filename)
  281. {
  282.     FILE *stream;
  283.     
  284.     /* Try the current directory */
  285.     stream = fopen(filename,"r");
  286.     if (stream != NULL) return(stream);
  287.     
  288.     /* Try the preferences folder */
  289.     OpenPreferencesFolder();
  290.     stream = fopen(filename,"r");
  291.     ClosePreferencesFolder();
  292.     return(stream);    
  293. }
  294.  
  295. /*
  296. ROUTINE: OpenCalFileWrite
  297. PURPOSE:
  298.     Open up a calibration file for appending.
  299.     
  300.     If the file exists in the current directory, it is used.
  301.     If not, then if it exists in the Preferences folder, it used.
  302.     If not, the file is created in the Preferences folder.
  303. */
  304.  
  305. FILE *OpenCalFileWrite(char *filename)
  306. {
  307.     FILE *stream;
  308.     
  309.     /* Try in the current directory */
  310.     stream = fopen(filename,"r");
  311.     if (stream != NULL) {
  312.         fclose(stream);
  313.         stream = fopen(filename,"a");
  314.         if (stream == NULL)
  315.             PrintfExit("OpenCalFileWrite: cannot reopen file \"%s\"",filename);
  316.         return(stream);
  317.     }
  318.     
  319.     /* Try the Preferences folder */
  320.     OpenPreferencesFolder();
  321.     stream = fopen(filename,"r");
  322.     ClosePreferencesFolder();
  323.     if (stream != NULL) {
  324.         fclose(stream);
  325.         OpenPreferencesFolder();
  326.         stream = fopen(filename,"a");
  327.         ClosePreferencesFolder();
  328.         if (stream == NULL)
  329.             PrintfExit("OpenCalFileWrite: cannot reopen file \"%s\" in Preferences folder"
  330.                 ,filename);
  331.         return(stream);
  332.     }
  333.     
  334.     /* Create it in the Preferences folder */
  335.     OpenPreferencesFolder();
  336.     stream = fopen(filename,"a");
  337.     ClosePreferencesFolder();
  338.     if (stream == NULL)
  339.         PrintfExit("OpenCalFileWrite: cannot create file \"%s\" in Preferences folder.",filename);
  340.     return(stream);
  341. }
  342.  
  343. /*
  344. ROUTINE: AppendDescriptions
  345. PURPOSE:
  346.     Appends the second descriptions array onto the end of the first,
  347.     which is reallocated with more space.
  348.     
  349.     The source array is not freed; the caller should do that.
  350. */
  351. void AppendDescriptions(Description **d,Description *s)
  352. {
  353.     Description *dTemp;
  354.     long n1, n2, n;
  355.     
  356.     n1 = NumberOfDescriptions(*d);
  357.     n2 = NumberOfDescriptions(s);
  358.     n = n1+n2;
  359.     dTemp = AllocateDescriptions(n);
  360.     CopyDescriptions(dTemp,*d);
  361.     CopyDescriptions(dTemp+n1,s);
  362.     FreeDescriptions(*d);
  363.     *d=dTemp;
  364. }
  365.  
  366. /*
  367. ROUTINE: CopyDescriptions
  368. PURPOSE:
  369.     Copy one null-terminated array of descriptions to another, which is assumed to
  370.     be big enough.
  371. */
  372. void CopyDescriptions(Description *d,Description *s)
  373. {
  374.     long i = 0;
  375.     
  376.     while ( !IsNullDescription(s[i]) ) {
  377.         d[i]=s[i];
  378.         i++;
  379.     }
  380.     d[i]=NullDescription();
  381. }
  382.  
  383. /*
  384. ROUTINE: AllocateDescriptions
  385. PURPOSE:
  386.     Allocate space for variable descriptions.
  387.     Adds one to the passed size to hold the null descriptor.
  388.     Nulls the first element.
  389. */
  390. Description *AllocateDescriptions(long n)
  391. {
  392.     Description *d;
  393.  
  394.     d = calloc(n+1,sizeof(Description));
  395.     if (d == NULL) {
  396.         PrintfExit("AllocateDescription: memory allocation failure.");
  397.     }
  398.     d[0]=NullDescription();
  399.     return(d);
  400. }
  401.  
  402.  
  403. /*
  404. ROUTINE: FreeDescriptions
  405. PURPOSE:
  406.     Free the description space.  Does not affect the described variables
  407.     themselves.
  408. */
  409. void FreeDescriptions(Description *d)
  410. {
  411.     free(d);    
  412. }
  413.  
  414. /*
  415. ROUTINE: NumberOfDescriptions
  416. PURPOSE:
  417.     Find the size of an array of descriptions.
  418.     
  419.     Does not count the trailing null description.
  420. */
  421. long NumberOfDescriptions(Description *d)
  422. {
  423.     long i=0;
  424.     
  425.     while ( !IsNullDescription(d[i]) ) i++;
  426.     return(i);
  427. }
  428.  
  429. /*
  430. ROUTINE: NullDescription
  431. PURPOSE:
  432.     Returns a null description.
  433.     Standard C specifies that static variables are initialized to zero.
  434. */
  435. Description NullDescription(void)
  436. {
  437.     static Description d;
  438.     return d;
  439. }
  440.  
  441. Description Describe(short type,void *ptr,char *name,const char *comment)
  442. {
  443.     static Description var;
  444.  
  445.     var=DescribeArray(type,ptr,name,comment,0L);
  446.     if(IsPtr(type)) var.sizedOnce=var.sized=0;
  447.     return var;
  448. }
  449.  
  450. Description DescribeArray(short type,void *ptr,char *name,const char *comment,...)
  451. /* WARNING: the dimensions must be (long) and the last argument must be 0L. */
  452. {
  453.     va_list args;
  454.     static Description var;
  455.     int i;
  456.     long dim;
  457.     
  458.     var.name=name;
  459.     var.ptr=ptr;
  460.     var.type=type;
  461.     var.firstElement=0;
  462.     for(i=0;i<ASSIGN_DIMS;i++)var.dim[i]=0;
  463.     var.comment=comment;
  464.     va_start(args,comment);
  465.     for(i=0;;i++){
  466.         dim=va_arg(args,long);
  467.         if(dim==0)break;
  468.         if(i>=ASSIGN_DIMS)PrintfExit("Describe/Array/FirstLast: "
  469.             "too many dimensions (or missing final 0L) for \"%s\".\n",var.name);
  470.         var.dim[i]=dim;
  471.     }
  472.     va_end(args);
  473.     if(var.type!=0 && var.ptr==NULL)
  474.         PrintfExit("Describe/Array/FirstLast: \"%s\" ptr is NULL.\n",var.name);
  475.     /* Note: we're clearing the malloced flag, which is the only safe assumption. */
  476.     var.malloced=0;
  477.     var.sizedOnce=var.sized=1;
  478.     return var;
  479. }
  480. Description DescribeFirstLast(short type,void *ptr,char *name
  481.     ,const char *comment,long firstElement,long lastElement)
  482. {
  483.     static Description var;
  484.     long dim;
  485.     
  486.     dim=1+lastElement-firstElement;
  487.     var=DescribeArray(type,ptr,name,comment,dim,0L);
  488.     var.firstElement=firstElement;
  489.     return var;
  490. }
  491. Description SetAVariable(short type,void *ptr,char *name,unsigned long dim
  492.     ,const char *comment)
  493. /* Old style, retained solely for compatibility */
  494. {
  495.     if(dim==0)return Describe(type,ptr,name,comment);
  496.     else return DescribeArray(type,ptr,name,comment,dim,0L);
  497. }
  498. int AllocateDescribedPtrVars(Description description[],const char *here,short flags)
  499. {
  500.     register Description *d;
  501.     
  502.     for(d=description;d->type!=0;d++){
  503.         if(IsPtr(d->type) && d->sizedOnce && !d->malloced){
  504.             assert(d->ptr!=NULL);
  505.             *(void **)d->ptr=malloc(Elements(d)*typeSize[d->type]);
  506.             if(*(void **)d->ptr==NULL){
  507.                 if(PRINTF_EXIT)PrintfExit("%s: no room for %ld bytes for \"%s\".\n"
  508.                     ,here,Elements(d)*typeSize[d->type],d->name);
  509.                 else return assignMemoryError;
  510.             }
  511.             d->sized=d->malloced=1;
  512.             InitializeADescribedVar(d,flags);
  513.         }
  514.     }
  515.     return 0;
  516. }
  517.  
  518. long CheckDescriptions(Description d[],const char *here,short flags)
  519. {
  520.     int error;
  521.     
  522.     if(flags&assignAlreadyChecked)return 0;
  523.     for(;d->type!=0;d++){
  524.         error=CheckADescription(d,here,flags);
  525.         if(error)return error;
  526.     }
  527.     return 0;
  528. }
  529.  
  530. long CheckADescription(Description *d,const char *here,short flags)
  531. {
  532.     char *s,*sOk;
  533.     
  534.     if(flags&assignAlreadyChecked)return 0;
  535.     if(d->type<=0 || d->type>=unknownType){
  536.         if(PRINTF_EXIT)PrintfExit("%s: \"%s\" has unknown type %ld.\n"
  537.             ,here,d->name,(long)d->type);
  538.         else return assignVariableError;
  539.     }
  540.     if(!IsPtr(d->type) && d->ptr==NULL){
  541.         if(PRINTF_EXIT)PrintfExit("%s: \"%s\" ptr is NULL.\n"
  542.             ,here,d->name);
  543.         else return assignVariableError;
  544.     }
  545.     /* Squeeze any space out of the name */
  546.     for(s=sOk=d->name;*s!=0;s++)if(!isspace(*s))*sOk++=*s;
  547.     *sOk=0;
  548.     /* Check name's syntax */
  549.     s=d->name;
  550.     if(ParseName(&s) || *s!=0){
  551.         if(PRINTF_EXIT)PrintfExit("%s: illegal name \"%s\".\n"
  552.             ,here,d->name);
  553.         else return assignVariableError;
  554.     }
  555.     return 0;
  556. }
  557.  
  558. int UnequalDescribedVars(Description d1[],Description d2[],short flags)
  559. /*
  560. Compares the data pointed to by the two Description arrays and returns
  561. true if the structs are legal and the data are equal, false otherwise.
  562. */
  563. {
  564.     int error;
  565.     
  566.     for(;d1->type!=0 && d2->type!=0;d1++,d2++){
  567.         error=UnequalDescribedVarPair(d1,d2,flags);
  568.         if(error)return error;
  569.     }
  570.     return 0;
  571. }
  572.  
  573. int CopyDescribedVars(Description d1[],Description d2[],short flags)
  574. /*
  575. Copies the data pointed to by the first Description array, overwriting the data
  576. pointed to by the second. Returns 0 if successful, i.e. the structs are legal and 
  577. the types and names are consistent, nonzero otherwise.
  578. */
  579. {
  580.     int error;
  581.     
  582.     for(;d1->type!=0 && d2->type!=0;d1++,d2++){
  583.         error=CopyDescribedVarPair(d1,d2,flags);
  584.         if(error)return error;
  585.     }
  586.     return 0;
  587. }
  588.  
  589. long Elements(Description *d)
  590. {
  591.     long elements=1;
  592.     int i;
  593.  
  594.     for(i=0;i<ASSIGN_DIMS && d->dim[i]>0;i++)elements*=d->dim[i];
  595.     return elements;
  596. }
  597. long Dims(Description *d)
  598. {
  599.     int i;
  600.  
  601.     for(i=0;i<ASSIGN_DIMS && d->dim[i]>0;i++) ;
  602.     return i;
  603. }
  604. void *ElementPtr(Description *d,long index)
  605. /* Returns NULL if PtrType array not allocated. */
  606. {
  607.     char *ptr;
  608.     
  609.     if(IsPtr(d->type)){
  610.         assert(d->ptr!=NULL);
  611.         ptr=*(void **)d->ptr;
  612.     }else ptr=d->ptr;
  613.     if(ptr!=NULL && d->dim[0]>0){
  614.         index+=d->firstElement;
  615.         ptr+=index*typeSize[d->type];
  616.     }
  617.     return ptr;
  618. }
  619. char *ElementName(char *s,Description *d,long index)
  620. {
  621.     long sub[ASSIGN_DIMS];
  622.     int i;
  623.     
  624.     ElementSubscript(d,index,sub);
  625.     sprintf(s,"%s",d->name);
  626.     for(i=0;i<Dims(d);i++)sprintf(s,"%s[%ld]",s,sub[i]);
  627.     return s;
  628. }
  629. char *DescriptionNameDimensions(Description *d);
  630. char *DescriptionNameDimensions(Description *d)
  631. {
  632.     int i;
  633.     static char s[64];
  634.     
  635.     sprintf(s,"%s",d->name);
  636.     for(i=0;d->dim[i]>0;i++)sprintf(s,"%s[%ld]",s,d->dim[i]);
  637.     assert(strlen(s)<sizeof(s));
  638.     return s;
  639. }
  640. void ElementSubscript(Description *d,long index,long sub[ASSIGN_DIMS])
  641. {
  642.     int i;
  643.  
  644.     for(i=0;i<ASSIGN_DIMS;i++)sub[i]=0;
  645.     if(Dims(d)){
  646.         for(i=Dims(d)-1;i>=0;i--){
  647.             sub[i]=index%d->dim[i];
  648.             index/=d->dim[i];
  649.         }
  650.         sub[Dims(d)-1]+=d->firstElement;
  651.     }
  652. }
  653. long ElementIndex(Description *d,long sub[ASSIGN_DIMS])
  654. {
  655.     int i;
  656.     long index=0;
  657.  
  658.     if(Dims(d)){
  659.     sub[Dims(d)-1]-=d->firstElement;
  660.     for(i=0;i<Dims(d);i++){
  661.         index*=d->dim[i];
  662.         index+=sub[i];
  663.     }
  664.     sub[Dims(d)-1]+=d->firstElement;
  665.     }
  666.     return index;
  667. }
  668. int GetDimensions(Description *d,int subscriptDims,long subscript[ASSIGN_DIMS],short flags)
  669. {
  670.     short i;
  671.     
  672.     flags;    /* dgp: prevent "unused argument" warning */
  673.     if(d->sizedOnce && Dims(d)!=subscriptDims)
  674.         return assignInconsistentDimensionsError;
  675.     if(!d->sized){
  676.         for(i=0;i<subscriptDims;i++)
  677.             if(d->dim[i]<subscript[i]+1)d->dim[i]=subscript[i]+1;
  678.         d->sizedOnce=1;
  679.     }
  680.     return 0;
  681. }
  682.  
  683. int UnequalDescribedVarPair(Description *d1,Description *d2,short flags)
  684. /*
  685. Compares the data pointed to by the two Description structs and returns true if the
  686. structs are legal and the data are equal, false otherwise. Comparison of floats
  687. and doubles allows a tolerance of +/- one part in a million--because converting
  688. to and from decimal may lose some precision--and ignores any NANs' indices (NAN04
  689. vs NANFF)--because they're not preserved.
  690. */
  691. {
  692.     unsigned char *p1,*p2;
  693.     long i,size,elements;
  694.     int error;
  695.     double a,b,e;
  696.     static const char here[]="UnequalDescribedVarPair";
  697.     char name[32+16*ASSIGN_DIMS];
  698.     
  699.     /* Squeeze space out of names */
  700.     error=CheckADescription(d1,here,flags);
  701.     if(error<0)return error;
  702.     error=CheckADescription(d2,here,flags);
  703.     if(error<0)return error;
  704.     if(d1->type!=d2->type
  705.         || !streq(d1->name,d2->name) 
  706.         || d1->firstElement!=d2->firstElement
  707.         || !streq(d1->comment,d2->comment))
  708.             {error=assignInconsistentDescriptionsError;goto done;}
  709.     for(i=0;i<ASSIGN_DIMS;i++)if(d1->dim[i]!=d2->dim[i])
  710.         {error=assignInconsistentDescriptionsError;goto done;}
  711.     p1=ElementPtr(d1,0);
  712.     p2=ElementPtr(d2,0);
  713.     size=typeSize[d1->type];
  714.     elements=Elements(d1);
  715.     if(!IsString(d1->type)){
  716.         if(memcmp(p1,p2,size*elements)!=0){
  717.             if(!IsFloating(d1->type)){error=assignUnequalDataError;goto done;}
  718.             for(i=0;i<elements;i++){
  719.                 switch(d1->type){
  720.                 case floatType:
  721.                     a=*(float *)p1;
  722.                     b=*(float *)p2;
  723.                     break;
  724.                 #if SHORT_DOUBLE_OK
  725.                     case shortDoubleType:
  726.                         a=*(short double *)p1;
  727.                         b=*(short double *)p2;
  728.                         break;
  729.                 #endif
  730.                 case doubleType:
  731.                     a=*(double *)p1;
  732.                     b=*(double *)p2;
  733.                     break;
  734.                 }
  735.                 /*  compare doubles */
  736.                 /*  ignore NaN type, since it's not preserved */
  737.                 if(IsNan(a)==0 || IsNan(b)==0){
  738.                     if(!IsFinite(a) || !IsFinite(b))
  739.                         {error=assignUnequalDataError;goto done;}
  740.                     e=a/b-1.0;
  741.                     if(e>TOLERANCE || e<-TOLERANCE)
  742.                         {error=assignUnequalDataError;goto done;}
  743.                 }
  744.                 p1+=size;
  745.                 p2+=size;
  746.             }
  747.         }
  748.     }else for(i=0;i<elements;i++){                            /* compare strings */
  749.         if(*(char **)p1!=*(char **)p2){
  750.             if((*(char **)p1==NULL) || (*(char **)p2==NULL)
  751.                 || !streq(*(char **)p1,*(char **)p2))
  752.                     {error=assignUnequalDataError;goto done;}
  753.         }
  754.         p1+=size;
  755.         p2+=size;
  756.     }
  757.     return 0;
  758. done:
  759.     if(!(flags&assignNoPrintfExit))switch(error){
  760.     case assignInconsistentDescriptionsError:
  761.         PrintfExit("%s: the two Descriptions of \"%s\" are inconsistent.\n"
  762.             ,here,d1->name);
  763.     case assignUnequalDataError:
  764.         PrintfExit("%s: the two instances of \"%s\" have significantly different values.\n"
  765.             ,here,ElementName(name,d1,i));
  766.     }
  767.     return error;
  768. }
  769.  
  770. int CopyDescribedVarPair(Description *d1,Description *d2,short flags)
  771. /*
  772. Copies the data pointed to by the first Description struct, overwriting the
  773. data pointed to by the second struct. Returns 0 if successful, i.e. the structs 
  774. are legal and the types and names are consistent, nonzero otherwise. 
  775. */
  776. {
  777.     unsigned char *p1,*p2;
  778.     long i,size,elements;
  779.     int error;
  780.     static const char here[]="CopyDescribedVarPair";
  781.     
  782.     /* Squeeze space out of names */
  783.     error=CheckADescription(d1,here,flags);
  784.     if(error<0)return error;
  785.     error=CheckADescription(d2,here,flags);
  786.     if(error<0)return error;
  787.     if(d1->type!=d2->type
  788.         || !streq(d1->name,d2->name) 
  789.         || d1->firstElement!=d2->firstElement)
  790.             {error=assignInconsistentDescriptionsError;goto done;}
  791.     for(i=0;i<ASSIGN_DIMS;i++)if(d1->dim[i]!=d2->dim[i])
  792.         {error=assignInconsistentDescriptionsError;goto done;}
  793.     p1=ElementPtr(d1,0);
  794.     p2=ElementPtr(d2,0);
  795.     size=typeSize[d1->type];
  796.     elements=Elements(d1);
  797.     if(!IsString(d1->type))memcpy(p2,p1,size*elements);
  798.     else{
  799.         for(i=0;i<elements;i++){                            /* copy strings */
  800.             if(!d2->malloced)*(char **)p2=NULL;
  801.             *(char **)p2=realloc(*(char **)p2,1+strlen(*(char **)p1));
  802.             if(*(void **)p2==NULL){
  803.                 if(PRINTF_EXIT)PrintfExit("%s: no room for %ld bytes for \"%s\".\n"
  804.                     ,here,1+strlen(*(char **)p1),d2->name);
  805.                 else return assignMemoryError;
  806.             }
  807.             strcpy(*(char **)p2,*(char **)p1);
  808.             p1+=size;
  809.             p2+=size;
  810.         }
  811.         d2->malloced=1;
  812.     }
  813.     return 0;
  814. done:
  815.     if(!(flags&assignNoPrintfExit))switch(error){
  816.     case assignInconsistentDescriptionsError:
  817.         PrintfExit("%s: the two Descriptions of \"%s\" are inconsistent.\n"
  818.             ,here,d1->name);
  819.     }
  820.     return error;
  821. }
  822.  
  823. void FreeAPtrDescription(Description *d,short flags)
  824. {
  825.     int i;
  826.     
  827.     flags;    /* dgp: prevent "unused argument" warning */
  828.     if(IsPtr(d->type)){
  829.         if(d->malloced)free(*(void **)d->ptr);
  830.         *(void **)d->ptr=NULL;
  831.         for(i=0;i<ASSIGN_DIMS;i++)d->dim[i]=0;
  832.         d->sizedOnce=d->sized=d->malloced=0;
  833.     }
  834. }
  835. void FreeAStringDescription(Description *d,short flags)
  836. {
  837.     static const char emptyString[]="";
  838.     
  839.     flags;    /* dgp: prevent "unused argument" warning */
  840.     if(IsString(d->type)){
  841.         if(d->malloced && !d->dim[0])free(*(char **)d->ptr);
  842.         *(const char **)d->ptr=emptyString;
  843.         d->malloced=0;
  844.     }
  845. }
  846. void FreeDescribedPtrVars(Description d[],short flags)
  847. {
  848.     for(;d->type!=0;d++)FreeAPtrDescription(d,flags);
  849. }
  850. void FreeADescribedVar(Description *d,short flags)
  851. {
  852.     FreeAPtrDescription(d,flags);
  853.     FreeAStringDescription(d,flags);
  854. }
  855. void FreeDescribedVars(Description d[],short flags)
  856. {
  857.     for(;d->type!=0;d++)FreeADescribedVar(d,flags);
  858. }
  859. void KeepDescribedVars(Description d[],short flags)
  860. {
  861.     flags;    /* dgp: prevent "unused argument" warning */
  862.     for(;d->type!=0;d++)d->malloced=0;
  863. }
  864. void KeepADescribedVar(Description *d,short flags)
  865. {
  866.     flags;    /* dgp: prevent "unused argument" warning */
  867.     d->malloced=0;
  868. }
  869.  
  870. long FindDescription(Description d[],void *ptr,short flags)
  871. {
  872.     long i;
  873.     
  874.     for(i=0;d[i].type!=0;i++)if(ptr==d[i].ptr)return i;
  875.     if(PRINTF_EXIT)PrintfExit("FindDescription: couldn't find your variable.\n");
  876.     return assignCouldntFindDescription;
  877. }
  878. long FindDescribedDim(Description d[],void *ptr,int i,short flags)
  879. {
  880.     long n;
  881.     
  882.     n=FindDescription(d,ptr,flags);
  883.     if(n<0)return n;
  884.     if(i<0 || i>=ASSIGN_DIMS)return 0;
  885.     return d[n].dim[i];
  886. }
  887.  
  888. long InitializeDescribedVars(Description d[],short flags)
  889. {
  890.     long j,n=0;
  891.     
  892.     for(;d->type!=0;d++){
  893.         j=InitializeADescribedVar(d,flags);
  894.         if(j<0)return j;
  895.         else n+=j;
  896.     }
  897.     return n;
  898. }
  899. long InitializeADescribedVar(Description *d,short flags)
  900. {
  901.     static const char here[]="InitializeADescribedVar";
  902.     int error;
  903.     
  904.     error=CheckADescription(d,here,flags);
  905.     if(error)return error;
  906.     if(IsPtr(d->type) && !d->malloced) *(void **)d->ptr=NULL;
  907.     if(IsPtr(d->type) || d->dim[0]){
  908.         Description w;
  909.         long i,j,n=0,elements;
  910.         
  911.         if(ElementPtr(d,0)==NULL)return n;
  912.         w=*d;
  913.         if(IsPtr(w.type))w.type+=charType-charPtrType;
  914.         for(i=0;i<ASSIGN_DIMS;i++)w.dim[i]=0;
  915.         w.sizedOnce=w.sized=1;
  916.         if(IsString(w.type))w.malloced=0;
  917.         w.firstElement=0;
  918.         elements=Elements(d);
  919.         for(i=0;i<elements;i++){
  920.             w.ptr=ElementPtr(d,i);
  921.             j=InitializeADescribedVar(&w,flags);
  922.             if(j<0)return j;
  923.             n+=j;
  924.         }
  925.         return n;
  926.     }
  927.     switch(d->type){
  928.     case charType:
  929.     case unsignedCharType:
  930.         *(char *)d->ptr=0;
  931.         break;
  932.     case shortType:
  933.     case unsignedShortType:
  934.         *(short *)d->ptr=0;
  935.         break;
  936.     case longType:
  937.     case unsignedLongType:
  938.         *(long *)d->ptr=0;
  939.         break;
  940.     case floatType:
  941.         *(float *)d->ptr=NAN;
  942.         break;
  943.     #if SHORT_DOUBLE_OK
  944.         case shortDoubleType:
  945.             *(short double *)d->ptr=NAN;
  946.             break;
  947.     #endif
  948.     case doubleType:
  949.         *(double *)d->ptr=NAN;
  950.         break;
  951.     case stringType:
  952.         FreeAStringDescription(d,flags);
  953.         break;
  954.     default:
  955.         /*  it shouldn't be possible to arrive here */
  956.         return assignVariableError;
  957.     }
  958.     return 1;
  959. }
  960.  
  961. long PrintAssignmentsToFile(const char *filename,Description d[],short flags)
  962. {
  963.     long n=0;
  964.     FILE *stream;
  965.     
  966.     stream=fopen(filename,"a");
  967.     if(stream==NULL)return assignFileError;
  968.     n=PrintAssignments(stream,d,flags);
  969.     fprintf(stream,NL);    /*  Add blank line to separate blocks */
  970.     fclose(stream);
  971.     return n;
  972. }
  973.  
  974. long PrintAssignments(FILE *stream,Description d[],short flags)
  975. {
  976.     Description *vStart=d;
  977.     long n=0,i;
  978.     
  979.     while(d->type!=0){
  980.         i=PrintAnAssignment(stream,d,flags);
  981.         if(i>0)fprintf(stream,NL);    /* new line */
  982.         if(i<0)return i;
  983.         n+=i;
  984.         d++;
  985.     }
  986.     return n;
  987. }
  988.  
  989. long PrintAnAssignmentOfElement(FILE *stream,Description *d,long index,short flags)
  990. {
  991.     Description w;
  992.     long n,i;
  993.     static const char here[]="PrintAnAssignmentOfElement";
  994.     
  995.     if(index<0 || index>=Elements(d))return assignSubscriptBoundsError;
  996.     w=*d;
  997.     for(i=0;i<ASSIGN_DIMS;i++)w.dim[i]=0;
  998.     w.firstElement=0;
  999.     w.comment=NULL;
  1000.     w.name=(char *)malloc(strlen(w.name)+16*Dims(d));
  1001.     if(w.name==NULL){
  1002.         if(PRINTF_EXIT)PrintfExit("%s: no room for %ld bytes.\n"
  1003.             ,here,(long)strlen(w.name)+16*Dims(d));
  1004.         else return assignMemoryError;
  1005.     }
  1006.     ElementName(w.name,d,index);
  1007.     w.ptr=ElementPtr(d,index);
  1008.     if(IsPtr(w.type))w.type+=charType-charPtrType;
  1009.     if(IsString(w.type))w.malloced=0;
  1010.     /*  Turn off checking, 'cause subscripted name is illegal. */
  1011.     n=PrintAnAssignment(stream,&w,flags|assignAlreadyChecked);
  1012.     free(w.name);
  1013.     return n;
  1014. }
  1015.  
  1016. long PrintAnAssignment(FILE *stream,Description *d,short flags)
  1017. {
  1018.     short hexEncode;
  1019.     char *string,name[32+16*ASSIGN_DIMS];
  1020.     static const char here[]="PrintAnAssignment";
  1021.     long index,n=0,row;
  1022.     int error;
  1023.     static short lineLength;/* zeroed before printing array or string and after \n. */
  1024.     Description w;
  1025.     
  1026.     error=CheckADescription(d,here,flags);
  1027.     if(error<0)return error;
  1028.     if(ElementPtr(d,0)==NULL)return n;
  1029.     if(IsPtr(d->type) || d->dim[0]){
  1030.         if(Dims(d))row=d->dim[Dims(d)-1];
  1031.         else row=1;
  1032.         hexEncode=IsIntegral(d->type) && !(flags&assignNoHexInts)
  1033.             &&(row>2+typeSize[d->type]);
  1034.         hexEncode|=IsFloating(d->type)&&(flags&assignHexFloats);
  1035.         if(hexEncode){
  1036.             for(index=0;index<Elements(d);index+=row){
  1037.                 lineLength=0;
  1038.                 w=*d;
  1039.                 if(IsString(w.type))w.malloced=0;
  1040.                 if(row>1)w.dim[Dims(d)-1]=0;
  1041.                 ElementName(name,&w,index/row);
  1042.                 lineLength+=fprintf(stream,"%s=",name);
  1043.                 string=BinaryToHex(row*typeSize[d->type]
  1044.                     ,ElementPtr(d,index),NULL);
  1045.                 if(string==NULL){
  1046.                     if(PRINTF_EXIT)PrintfExit("%s: no room for %ld bytes.\n"
  1047.                         ,here,2L*row*typeSize[d->type]);
  1048.                     else return assignMemoryError;
  1049.                 }
  1050.                 PrintQuotedString(stream,&lineLength,string,"\"","\"");
  1051.                 free(string);
  1052.                 lineLength+=fprintf(stream,";");
  1053.                 if(index<Elements(d)-row)lineLength+=fprintf(stream,"\\" NL);
  1054.             }
  1055.             n=Elements(d);
  1056.         }else{
  1057.             long i,assignLength,oldLineLength,elements;
  1058.             
  1059.             lineLength=0;
  1060.             elements=Elements(d);
  1061.             for(i=0;i<elements;i++){
  1062.                 oldLineLength=lineLength;
  1063.                 n+=PrintAnAssignmentOfElement(stream,d,i,flags);
  1064.                 assignLength=lineLength-oldLineLength;
  1065.                 if(lineLength+assignLength+1>=MAX_LINELENGTH && i<elements-1){
  1066.                     fprintf(stream,"\\" NL);
  1067.                     lineLength=0;
  1068.                     lineLength+=fprintf(stream,"    ");
  1069.                 }
  1070.             }
  1071.         }
  1072.         if(d->comment!=NULL && lineLength+strcspn(d->comment,NL)+6>=MAX_LINELENGTH){
  1073.             fprintf(stream,"\\" NL);
  1074.             lineLength=0;
  1075.             lineLength+=fprintf(stream,"    ");
  1076.         }
  1077.         goto comment;
  1078.     }
  1079.     assert(d->dim[0]==0);
  1080.     if(IsString(d->type))lineLength=0;
  1081. fflush(stream);
  1082.     lineLength+=fprintf(stream,"%s=",d->name);
  1083. fflush(stream);
  1084.     n=1;
  1085.     switch(d->type){
  1086.     case charType:
  1087.         lineLength+=fprintf(stream,"%ld;",(long)*(char *)d->ptr);
  1088.         break;
  1089.     case unsignedCharType:
  1090.         lineLength+=fprintf(stream,"%lu;",(unsigned long)*(unsigned char *)d->ptr);
  1091.         break;
  1092.     case shortType:
  1093.         lineLength+=fprintf(stream,"%ld;",(long)*(short *)d->ptr);
  1094.         break;
  1095.     case unsignedShortType:
  1096.         lineLength+=fprintf(stream,"%lu;",(unsigned long)*(unsigned short *)d->ptr);
  1097.         break;
  1098.     case longType:
  1099.         lineLength+=fprintf(stream,"%ld;",*(long *)d->ptr);
  1100.         break;
  1101.     case unsignedLongType:
  1102.         lineLength+=fprintf(stream,"%lu;",*(unsigned long *)d->ptr);
  1103.         break;
  1104.     case floatType:
  1105.     #if SHORT_DOUBLE_OK
  1106.     case shortDoubleType:
  1107.     #endif
  1108.     case doubleType:
  1109.         if(flags&assignHexFloats){
  1110.             string=BinaryToHex(typeSize[d->type],d->ptr,NULL);
  1111.             if(string==NULL){
  1112.                 if(PRINTF_EXIT)PrintfExit("%s: no room for %ld bytes.\n"
  1113.                     ,here,2L*typeSize[d->type]);
  1114.                 else return assignMemoryError;
  1115.             }
  1116.             lineLength+=fprintf(stream,"\"%s\";",string);
  1117.             free(string);
  1118.         }else switch(d->type){
  1119.             case floatType: 
  1120.                 lineLength+=fprintf(stream,"%.*g;",FLT_DIG,*(float *)d->ptr);
  1121.                 break;
  1122.             #if SHORT_DOUBLE_OK
  1123.                 case shortDoubleType: 
  1124.                     lineLength+=fprintf(stream,"%.*g;",DBL_DIG,*(short double *)d->ptr);
  1125.                     break;
  1126.             #endif
  1127.             case doubleType: 
  1128.                 lineLength+=fprintf(stream,"%.*g;",DBL_DIG,*(double *)d->ptr);
  1129.                 break;
  1130.         }
  1131.         break;
  1132.     case stringType:
  1133.         PrintQuotedString(stream,&lineLength,*(const char **)d->ptr,"\"","\"");
  1134.         lineLength+=fprintf(stream,";");
  1135.         break;
  1136.     default:
  1137.         /*  It shouldn't be possible to arrive here. */
  1138.         PrintfExit("PrintAnAssignment: oops. \"%s\" of type (%s) fell through a crack.\n"
  1139.             ,d->name,typeName[d->type]);
  1140.         n=0;
  1141.     }
  1142. comment:
  1143.     if(d->comment!=NULL && !(flags&assignNoComment))
  1144.         lineLength+=fprintf(stream," /* %s */",d->comment);
  1145.     return n;
  1146. }
  1147.  
  1148. int AssignmentLineWasBlank(void)
  1149. {
  1150.     extern int lineWasBlank;
  1151.  
  1152.     return lineWasBlank;
  1153. }
  1154.  
  1155. long ReadAssignmentFile(const char *filename,Description d[],short flags)
  1156. {
  1157.     long n=0;
  1158.     FILE *stream;
  1159.     static const char here[]="ReadAssignmentFile";
  1160.     
  1161.     stream=fopen(filename,"r");
  1162.     if(stream==NULL)return assignFileError;
  1163.     n=ReadAssignmentStream(stream,d,flags);
  1164.     fclose(stream);
  1165.     return n;
  1166.     
  1167.     #if 0
  1168.     if(!(flags&assignLocalCall)){
  1169.             /* First pass: scan for dimensions of unallocated Ptr variables.*/
  1170.             ReadAssignmentFile(filename,d,flags|assignScan|assignLocalCall);
  1171.             flags&=~assignScan;
  1172.             flags|=assignLocalCall;
  1173.             error=AllocateDescribedPtrVars(d,here,flags);
  1174.             if(error)return error;
  1175.             /* Second pass: read data again, including the newly allocated Ptr variables */
  1176.         }
  1177.         stream=fopen(filename,"r");
  1178.         if(stream==NULL)return assignFileError;
  1179.         do{
  1180.             int i;
  1181.             i=ReadAssignmentLine(stream,d,flags);
  1182.             if(i>=0)n+=i;
  1183.             else{
  1184.                 n=i;
  1185.                 break;
  1186.             }
  1187.         }while(!feof(stream));
  1188.         fclose(stream);
  1189.         return n;
  1190.     #endif
  1191. }
  1192.  
  1193. long ReadAssignmentStream(FILE *stream,Description d[],short flags)
  1194. {
  1195.     long n=0;
  1196.     int error;
  1197.     static const char here[]="ReadAssignmentStream";
  1198.     
  1199.     if(!(flags&assignLocalCall)){
  1200.         /* First pass: scan for dimensions of unallocated Ptr variables.*/
  1201.         long position=ftell(stream);
  1202.         ReadAssignmentStream(stream,d,flags|assignScan|assignLocalCall);
  1203.         flags&=~assignScan;
  1204.         flags|=assignLocalCall;
  1205.         fseek(stream,position,SEEK_SET);
  1206.         error=AllocateDescribedPtrVars(d,here,flags);
  1207.         if(error)return error;
  1208.         /* Second pass: read data again, including the newly allocated Ptr variables */
  1209.     }
  1210.     do{
  1211.         int i;
  1212.         i=ReadAssignmentLine(stream,d,flags);
  1213.         if(i>=0)n+=i;
  1214.         else{
  1215.             n=i;
  1216.             break;
  1217.         }
  1218.     }while(!feof(stream));
  1219.     return n;
  1220. }
  1221.  
  1222. long ReadAssignmentBlock(FILE *stream,Description d[],short flags)
  1223. {
  1224.     long n=0;
  1225.     int error;
  1226.     static const char here[]="ReadAssignmentBlock";
  1227.     
  1228.     if(!(flags&assignLocalCall)){
  1229.         /* First pass: scan for dimensions of unallocated Ptr variables.*/
  1230.         long position=ftell(stream);
  1231.         ReadAssignmentBlock(stream,d,flags|assignScan|assignLocalCall);
  1232.         flags&=~assignScan;
  1233.         flags|=assignLocalCall;
  1234.         fseek(stream,position,SEEK_SET);
  1235.         error=AllocateDescribedPtrVars(d,here,flags);
  1236.         if(error)return error;
  1237.         /* Second pass: read data again, including the newly allocated Ptr variables */
  1238.         n=ReadAssignmentBlock(stream,d,flags);
  1239.         return n;
  1240.     }
  1241.     do{
  1242.         int i;
  1243.         i=ReadAssignmentLine(stream,d,flags);
  1244.         if(i>=0)n+=i;
  1245.         else{
  1246.             n=i;
  1247.             break;
  1248.         }
  1249.     }while(!AssignmentLineWasBlank());
  1250.     return n;
  1251. }
  1252.  
  1253. static char *lineBuffer;    /* global because it would be messy to pass this address to
  1254.                             all the routines below that need to call ParsingError */
  1255. long ReadAssignmentLine(FILE *stream,Description description[],short flags)
  1256. {
  1257.     register Description *d;
  1258.     Description *vMatch;
  1259.     long j,n=0,nAssign;
  1260.     int i;
  1261.     char *s,*sOld;
  1262.     long ftellOld;
  1263.     void *ptr;
  1264.     extern int lineWasBlank;
  1265.     int hexAllowed,subscriptDims,outOfBounds,unknown;
  1266.     long subscript[ASSIGN_DIMS],index;
  1267.     int error;
  1268.     Description scratchDescription,*dScratch;
  1269.     double scratchDouble;
  1270.     long scratchLong;
  1271.     void *scratchPtr;
  1272.     static const char here[]="ReadAssignmentLine";
  1273.     
  1274.     if(!(flags&assignLocalCall)){
  1275.         /* First pass: scan for dimensions of unallocated Ptr variables.*/
  1276.         long position=ftell(stream);
  1277.         ReadAssignmentLine(stream,description,flags|assignScan|assignLocalCall);
  1278.         flags&=~assignScan;
  1279.         flags|=assignLocalCall;
  1280.         fseek(stream,position,SEEK_SET);
  1281.         error=AllocateDescribedPtrVars(description,here,flags);
  1282.         if(error)return error;
  1283.         /* Second pass: read data again, including the newly allocated Ptr variables */
  1284.     }
  1285.     if(stream==NULL)return 0;
  1286.     error=CheckDescriptions(description,here,flags);
  1287.     if(error)return error;
  1288.     lineWasBlank=TRUE;
  1289.     lineBuffer=(char *)malloc(BUFFER_SIZE);
  1290.     if(lineBuffer==NULL){
  1291.         if(PRINTF_EXIT)PrintfExit("%s: no room for %ld bytes.\n"
  1292.             ,here,(long)BUFFER_SIZE);
  1293.         else return assignMemoryError;
  1294.     }
  1295.     dScratch=&scratchDescription;
  1296.     s=NULL;
  1297.     do{
  1298.         /* parse the name */
  1299.         if(s==NULL)
  1300.             s=NextTokenInThisOrNextLine(stream,lineBuffer,s,flags&~assignNeedMore);
  1301.         else s=NextTokenInLine(stream,lineBuffer,s,flags);
  1302.         if(s==NULL){
  1303.             free(lineBuffer);
  1304.             return n;
  1305.         }
  1306.         *dScratch=Describe(unknownType,&scratchPtr,GetName(&s,flags),NULL);
  1307.         if(dScratch->name==NULL){
  1308.             free(lineBuffer);
  1309.             return assignMemoryError;
  1310.         }
  1311.         dScratch->sizedOnce=dScratch->sized=dScratch->malloced=0;
  1312.         d=dScratch;
  1313.         unknown=1;
  1314.         for(vMatch=&description[0];vMatch->type!=0;vMatch++){
  1315.             if(streq(dScratch->name,vMatch->name)){
  1316.                 d=vMatch;
  1317.                 unknown=0;
  1318.                 break;
  1319.             }
  1320.         }
  1321.         if(unknown && (flags&assignReportUnknown)){
  1322.             if(PRINTF_EXIT)ParsingError(s,"unknown variable");
  1323.             else {
  1324.                 free(dScratch->name);    // 7/16/94
  1325.                 free(lineBuffer);
  1326.                 return assignUnknownVariableError;
  1327.             }
  1328.         }
  1329.         hexAllowed=IsIntegral(d->type)&&!(flags&assignNoHexInts)
  1330.             || IsFloating(d->type)&&(flags&assignHexFloats);
  1331.         s=NextToken(stream,lineBuffer,s,flags);
  1332.         subscriptDims=0;
  1333.         for(i=0;i<ASSIGN_DIMS;i++)subscript[i]=0;
  1334.         outOfBounds=0;
  1335.         if(IsPtr(d->type) && !d->malloced)outOfBounds=1;
  1336.  
  1337.         /* parse subscripts, e.g. [123][3] */
  1338.         for(i=0;i<Dims(d) || !d->sized;i++){
  1339.             /* parse a subscript, e.g. [123] */
  1340.             if(*s != '['){
  1341.                 if(hexAllowed && subscriptDims==Dims(d)-1)break;
  1342.                 if(!d->sized)break;
  1343.                 if(PRINTF_EXIT)ParsingError(s,"expected \"[\"");
  1344.                 else {
  1345.                     free(dScratch->name);    // 7/16/94
  1346.                     free(lineBuffer);
  1347.                     return assignSubscriptError;
  1348.                 }
  1349.             }
  1350.             if(i==ASSIGN_DIMS){
  1351.                 if(PRINTF_EXIT)ParsingError(s,"too many dimensions");
  1352.                 else {
  1353.                     free(dScratch->name);    // 7/16/94
  1354.                     free(lineBuffer);
  1355.                     return assignSubscriptError;
  1356.                 }
  1357.             }
  1358.             s++;
  1359.             s=NextToken(stream,lineBuffer,s,flags);
  1360.             sOld=s;
  1361.             ftellOld=ftell(stream);
  1362.             subscript[i]=strtolN(s,&s,0);
  1363.             subscriptDims=i+1;
  1364.             if(s==sOld && ftellOld==ftell(stream)){
  1365.                 if(PRINTF_EXIT)ParsingError(s,"expected subscript");
  1366.                 else {
  1367.                     free(dScratch->name);    // 7/16/94
  1368.                     free(lineBuffer);
  1369.                     return assignSubscriptError;
  1370.                 }
  1371.             }
  1372.             j=subscript[i];
  1373.             if(i==Dims(d)-1)j-=d->firstElement;
  1374.             if(j<0 || d->sized && j>=d->dim[i]){
  1375.                 if(flags&assignReportUnknown){
  1376.                     if(PRINTF_EXIT)ParsingError(s,"subscript out of bounds: %s"
  1377.                         ,DescriptionNameDimensions(d));
  1378.                     else {
  1379.                         free(dScratch->name);    // 7/16/94
  1380.                         free(lineBuffer);
  1381.                         return assignSubscriptBoundsError;
  1382.                     }
  1383.                 }
  1384.                 outOfBounds=1;
  1385.             }
  1386.             s=NextToken(stream,lineBuffer,s,flags);
  1387.             if(*s != ']'){
  1388.                 if(PRINTF_EXIT)ParsingError(s,"expected \"]\"");
  1389.                 else {
  1390.                     free(dScratch->name);    // 7/16/94
  1391.                     free(lineBuffer);
  1392.                     return assignSubscriptError;
  1393.                 }
  1394.             }
  1395.             s++;
  1396.             s=NextToken(stream,lineBuffer,s,flags);
  1397.         }
  1398.  
  1399.         /* parse the equal sign */
  1400.         if(*s != '='){
  1401.             if(PRINTF_EXIT)ParsingError(s,"expected \"=\"");
  1402.             else {
  1403.                 free(dScratch->name);    // 7/16/94
  1404.                 free(lineBuffer);
  1405.                 return assignEqualsError;
  1406.             }
  1407.         }
  1408.         s++;
  1409.         
  1410.         /* parse the value */
  1411.         s=NextToken(stream,lineBuffer,s,flags);
  1412.         if(d->sized && Dims(d)!=subscriptDims 
  1413.             && !(*s=='"'  && Dims(d)-1==subscriptDims)){
  1414.             if(PRINTF_EXIT)
  1415.                 ParsingError(s,"\"%s\": wrong number of subscripts",DescriptionNameDimensions(d));
  1416.             else {
  1417.                 free(dScratch->name);    // 7/16/94
  1418.                 free(lineBuffer);
  1419.                 return assignSubscriptError;
  1420.             }
  1421.         }
  1422.         if(d->type==unknownType){
  1423.             /*  choose type that can accept the data, so we can parse and discard it. */
  1424.             if(*s=='"')d->type=stringType;
  1425.             else if(streq2(s,"0x") || streq2(s,"0X") || *s=='\''
  1426.                 || !(flags&assignNoHexInts) && *s=='"')d->type=longType;
  1427.             else d->type=doubleType;
  1428.         }
  1429.         if(unknown || outOfBounds){
  1430.             /* use scratch scalar to receive the assignment */
  1431.             short type=d->type;
  1432.             if(IsPtr(type))type+=charType-charPtrType;
  1433.             if(IsString(type))
  1434.                 *dScratch=Describe(type,&scratchPtr,d->name,NULL);
  1435.             else if(IsIntegral(type))
  1436.                 *dScratch=Describe(type,&scratchLong,d->name,NULL);
  1437.             else if(IsFloating(type))
  1438.                 *dScratch=Describe(type,&scratchDouble,d->name,NULL);
  1439.             d=dScratch;
  1440.             index=0;
  1441.             /* Note: d is now inconsistent with subscript and subscriptDims */
  1442.         }else index=ElementIndex(d,subscript);
  1443.         ptr=ElementPtr(d,index);
  1444.         sOld=s;
  1445.         ftellOld=ftell(stream);
  1446.         nAssign=1;
  1447.         error=0;
  1448.         if(*s=='"' && !IsString(d->type) && hexAllowed){
  1449.             long bytes,elements;
  1450.             if(unknown || outOfBounds)
  1451.                 nAssign=HexAssignment(stream,lineBuffer,&s,d,0,index,&bytes,flags);
  1452.             else nAssign=HexAssignment(stream,lineBuffer,&s,d,subscriptDims,index
  1453.                 ,&bytes,flags);
  1454.             if(!unknown){
  1455.                 elements=bytes/typeSize[vMatch->type];
  1456.                 if(elements>1){
  1457.                     subscript[subscriptDims++]=elements-1;
  1458.                     error=GetDimensions(vMatch,subscriptDims,subscript,flags);
  1459.                     subscript[--subscriptDims]=0;
  1460.                 }else error=GetDimensions(vMatch,subscriptDims,subscript,flags);
  1461.             }
  1462.         }else{
  1463.             if(!unknown)error=GetDimensions(vMatch,subscriptDims,subscript,flags);
  1464.             else error=0;
  1465.             if(!error)switch(d->type){
  1466.             default:
  1467.                 assert(0 /* It shouldn't be possible to arrive here. */);
  1468.                 nAssign=0;
  1469.                 break;
  1470.             case charType:
  1471.             case charPtrType:
  1472.                 *(char *)ptr=strtolN(s,&s,0);
  1473.                 break;
  1474.             case unsignedCharType:
  1475.             case unsignedCharPtrType:
  1476.                 *(unsigned char *)ptr=strtoulN(s,&s,0);
  1477.                 break;
  1478.             case shortType:
  1479.             case shortPtrType:
  1480.                 *(short *)ptr=strtolN(s,&s,0);
  1481.                 break;
  1482.             case unsignedShortType:
  1483.             case unsignedShortPtrType:
  1484.                 *(unsigned short *)ptr=strtoulN(s,&s,0);
  1485.                 break;
  1486.             case longType:
  1487.             case longPtrType:
  1488.                 *(long *)ptr=strtolN(s,&s,0);
  1489.                 break;
  1490.             case unsignedLongType:
  1491.             case unsignedLongPtrType:
  1492.                 *(unsigned long *)ptr=strtoulN(s,&s,0);
  1493.                 break;
  1494.             case floatType:
  1495.             case floatPtrType:
  1496.                 *(float *)ptr=strtodN(s,&s);
  1497.                 break;
  1498.             #if SHORT_DOUBLE_OK
  1499.                 case shortDoubleType:
  1500.                 case shortDoublePtrType:
  1501.                     *(short double *)ptr=strtodN(s,&s);
  1502.                     break;
  1503.             #endif
  1504.             case doubleType:
  1505.             case doublePtrType:
  1506.                 *(double *)ptr=strtodN(s,&s);
  1507.                 break;
  1508.             case stringType:
  1509.                 if(d->malloced && !d->dim[0])free(*(char **)ptr);
  1510.                 *(char **)ptr=GetQuotedString(stream,lineBuffer,s,&s,flags);
  1511.                 d->malloced=1;
  1512.                 break;
  1513.             }
  1514.         }
  1515.         if(error==assignInconsistentDimensionsError){
  1516.             if(PRINTF_EXIT)ParsingError(s,"inconsistent dimensionality of \"%s\""
  1517.                 ,DescriptionNameDimensions(d));
  1518.             else {
  1519.                 free(dScratch->name);    // 7/16/94
  1520.                 free(lineBuffer);
  1521.                 return error;
  1522.             }
  1523.         }
  1524.         if(s==sOld && ftellOld==ftell(stream)){
  1525.             if(PRINTF_EXIT)ParsingError(s,"expected %s",typeName[d->type]);
  1526.             else {
  1527.                 free(dScratch->name);    // 7/16/94
  1528.                 free(lineBuffer);
  1529.                 return assignConstantError;
  1530.             }
  1531.         }
  1532.  
  1533.         /* parse the semicolon */
  1534.         s=NextToken(stream,lineBuffer,s,flags);
  1535.         if(*s!=';'){
  1536.             if(PRINTF_EXIT)ParsingError(s,"expected \";\"");
  1537.             else {
  1538.                 free(dScratch->name);    // 7/16/94
  1539.                 free(lineBuffer);
  1540.                 return assignSemicolonError;
  1541.             }
  1542.         }
  1543.         s++;
  1544.         
  1545.         if(ECHO_ASSIGNMENTS){
  1546.             if(unknown)printf("/*UNKNOWN: ");
  1547.             else if(outOfBounds)printf("/*OUT OF BOUNDS: ");
  1548.             if(!subscriptDims)PrintAnAssignment(stdout,d
  1549.                 ,(flags&~assignHexFloats)|assignNoComment);
  1550.             else PrintAnAssignmentOfElement(stdout,d,index
  1551.                 ,(flags&~assignHexFloats)|assignNoComment);
  1552.             if(outOfBounds || unknown)printf("*/ ");
  1553.         }
  1554.         free(dScratch->name);    // 7/16/94
  1555.         dScratch->name=NULL;
  1556.         FreeADescribedVar(dScratch,flags);
  1557.         if(d!=dScratch)n+=nAssign;
  1558.     } while(1);
  1559. }
  1560.  
  1561. char *GetName(char **sPtr,short flags)
  1562. /*  Gets a variable's name.  */
  1563. {
  1564.     char *s,*sEnd,*name;
  1565.     long bytes=0,i;
  1566.     static const char here[]="ReadAssignmentLine/CheckADescription:GetName";
  1567.     
  1568.     s=*sPtr;
  1569.     if(ParseName(&s))if(PRINTF_EXIT)ParsingError(s,"expected name");
  1570.     sEnd=s;
  1571.     bytes=0;
  1572.     for(s=*sPtr;!isspace(*s) && s!=sEnd;s++)bytes++;
  1573.     name=(char *)malloc(bytes+1);
  1574.     if(name==NULL){
  1575.         if(PRINTF_EXIT)ParsingError(s,"%s: no room for %ld bytes.\n"
  1576.             ,here,bytes+1);
  1577.         else return NULL;
  1578.     }
  1579.     for(i=0;i<bytes;i++){
  1580.         while(isspace((*sPtr)[i]))(*sPtr)++;
  1581.         name[i]=(*sPtr)[i];
  1582.     }
  1583.     name[bytes]=0;
  1584.     *sPtr=s;
  1585.     return name;
  1586. }
  1587.  
  1588. int ParseName(char **sPtr)
  1589. /*
  1590. Parse a variable's name. It may be just a C identifier: alphabetic (or _)
  1591. followed by any number of alphanumeric (or _). Or it may be made up of multiple
  1592. identifiers joined by "." or "->" infix operators, e.g. "LP->p". 
  1593. */
  1594. {
  1595.     char *s;
  1596.     int error=0;
  1597.     
  1598.     s=*sPtr;
  1599.     while(*s!=0){
  1600.         for(;isspace(*s);s++) ;
  1601.         if(!(isalpha(*s)||*s=='_')){
  1602.             error=1;
  1603.             break;
  1604.         }
  1605.         for(;isalnum(*s)||*s=='_';s++) ;
  1606.         for(;isspace(*s);s++) ;
  1607.         if(*s=='.'){
  1608.             s++;
  1609.             continue;
  1610.         }
  1611.         if(streq2(s,"->")){
  1612.             s+=2;
  1613.             continue;
  1614.         }
  1615.         break;
  1616.     }
  1617.     *sPtr=s;
  1618.     return error;
  1619. }
  1620.  
  1621. long HexAssignment(FILE *stream,char *lineBuffer,char **sPtr,Description *d
  1622.     ,int subscriptDims,long index,long *bytesPtr,short flags)
  1623. {
  1624.     char *string,*s;
  1625.     long bytes,excess,n;
  1626.     int error;
  1627.     void *ptr;
  1628.     
  1629.     if(!(flags&assignScan) 
  1630.         && (subscriptDims<Dims(d)-1 || subscriptDims>Dims(d)))return assignSubscriptError;
  1631.     ptr=ElementPtr(d,index);
  1632.     /*
  1633.     Read in hex data.
  1634.     For scalar insist on exactly the right number of bytes.
  1635.     For array, if flags&assignReportUnknown then insist on exactly the right number
  1636.     of bytes; otherwise merely insist that the binary object size be a 
  1637.     multiple of the data element size.
  1638.     */
  1639.     s=*sPtr;
  1640.     string=GetQuotedString(stream,lineBuffer,s,&s,flags);
  1641.     *bytesPtr=strlen(string)/2;
  1642.     bytes=typeSize[d->type];
  1643.     if(subscriptDims==Dims(d)-1)bytes*=d->dim[subscriptDims];
  1644.     excess=strlen(string)-2*bytes;
  1645.     if(subscriptDims==Dims(d)-1 && !(excess>0 && (flags&assignReportUnknown)))
  1646.         excess=strlen(string)%(2*typeSize[d->type]);
  1647.     if(excess!=0 && !(flags&assignScan)){
  1648.         free(string);
  1649.         if(PRINTF_EXIT){
  1650.             if(excess>0)ParsingError(s,"\"%s=\", %ld extra hex digits",d->name,excess);
  1651.             else ParsingError(s,"\"%s=\", %ld too few hex digits",d->name,-excess);
  1652.         }else return assignHexError;
  1653.     }
  1654.     string[strlen(string)-strlen(string)%(2*typeSize[d->type])]=0;
  1655.     if(strlen(string)>2*bytes)string[2*bytes]=0;
  1656.     if(ptr!=NULL){
  1657.         error=HexToBinary(string,ptr);
  1658.         if(error){
  1659.             if(PRINTF_EXIT)ParsingError(s,"\"%s=\", hex string contains non hex char:\n\"%s\"\n"
  1660.                 ,d->name,string);
  1661.             else {
  1662.                 free(string);
  1663.                 return assignHexError;
  1664.             }
  1665.         }
  1666.         n=strlen(string)/(2*typeSize[d->type]);    /*  number of assigments */
  1667.     }else n=0;
  1668.     free(string);
  1669.     *sPtr=s;
  1670.     return n;
  1671. }
  1672.  
  1673. char *GetQuotedString(FILE *stream,char *lineBuffer,char *s,char **sPtr,short flags)
  1674. /*
  1675. Returns a newly malloced string copied from the lineBuffer (starting at s),
  1676. supplemented if necessary, by reading in further lines from the stream. The
  1677. translation from input to output mimics what would be performed by a C compiler.
  1678. Each line of input must fit in the BUFFER_SIZE byte lineBuffer, but the
  1679. resulting string (concatenated across continuations and adjacent strings) can be
  1680. of any length, limited only by how much space can be obtained by malloc. Returns
  1681. NULL if an error occurs (e.g. can't malloc needed space).
  1682. */
  1683. {
  1684.     char *newS,*oldString,*newString;
  1685.     size_t stringSize;
  1686.     long j;
  1687.     static const char here[]="GetQuotedString";
  1688.     
  1689.     /* parse the opening quote mark */
  1690.     if(*s!='"'){
  1691.         if(PRINTF_EXIT)ParsingError(s,"expected '\"'");
  1692.         else return NULL;
  1693.     }
  1694.     s++;
  1695.     stringSize=0;
  1696.     newS=newString=NULL;
  1697.     do{
  1698.         /* copy string, translating any backslash escapes */
  1699.         while(1){
  1700.             j=strcspn(s,"\\\"");
  1701.             if(stringSize==0 || strlen(newString)+j+2>stringSize){
  1702.                 /*  allocate a string that's big enough */
  1703.                 stringSize+=j;
  1704.                 stringSize*=2;
  1705.                 if(stringSize<BUFFER_SIZE)stringSize=BUFFER_SIZE;
  1706.                 oldString=newString;
  1707.                 newString=malloc(stringSize);
  1708.                 if(newString==NULL){
  1709.                     if(oldString!=NULL)free(oldString);
  1710.                     if(PRINTF_EXIT)PrintfExit("%s: no room for %ld bytes.\n"
  1711.                         ,here,(long)stringSize);
  1712.                     else return NULL;
  1713.                 }
  1714.                 if(oldString!=NULL){
  1715.                     strcpy(newString,oldString);
  1716.                     free(oldString);
  1717.                 }
  1718.                 newS+=newString-oldString;
  1719.             }
  1720.             strncpy(newS,s,j);
  1721.             s+=j;
  1722.             newS+=j;
  1723.             *newS=0;
  1724.             if(streq2(s,"\\" NL)){
  1725.                 s+=2;
  1726.                 continue;
  1727.             }
  1728.             if(*s=='\\'){
  1729.                 *newS++=strtoc(s,&s);
  1730.                 *newS=0;
  1731.             }else break;
  1732.         };
  1733.         if(strlen(s)==0){
  1734.             s=ReadLine(lineBuffer,BUFFER_SIZE,stream,flags|assignNeedMore);
  1735.             continue;
  1736.         }
  1737.         /* parse the closing quote mark */
  1738.         if(*s!='"'){
  1739.             if(PRINTF_EXIT)ParsingError(s,"expected '\"'");
  1740.             else{
  1741.                 free(newString);
  1742.                 return NULL;
  1743.             }
  1744.         }
  1745.         s++;
  1746.         
  1747.         /* look for another opening quote mark. Concatenate adjacent strings */
  1748.         s=NextToken(stream,lineBuffer,s,flags);
  1749.         if(*s!='"')break;
  1750.         s++;
  1751.     }while(1);
  1752.     /* shrink string allocation down to what we actually used */
  1753.     stringSize=1+strlen(newString);
  1754.     newString=realloc(newString,stringSize);
  1755.     if(newString==NULL){
  1756.         if(PRINTF_EXIT)PrintfExit("%s: no room for %ld bytes.\n"
  1757.             ,here,(long)stringSize);
  1758.         else return NULL;
  1759.     }
  1760.     *sPtr=s;
  1761.     return newString;
  1762. }
  1763.  
  1764. void ParsingError(char *s,char *format,...)
  1765. {
  1766.     va_list args;
  1767.     long i;
  1768.     static short lineLength=0;/* zeroed after each \n. */
  1769.  
  1770.     printf("\007\nReadAssignmentLine: ");
  1771.     va_start(args,format);
  1772.     vfprintf(stdout,format,args);
  1773.     va_end(args);
  1774.     if(s==NULL)PrintfExit(".\n");
  1775.     printf(". Quitting at |.\n");
  1776. //    printf("%s",lineBuffer);
  1777. //    if(lineBuffer[strlen(lineBuffer)-1]!=NEWLINE)printf("...\n");
  1778.     if(lineBuffer[strlen(lineBuffer)-1]==NEWLINE)lineBuffer[strlen(lineBuffer)-1]=0;
  1779.     PrintQuotedString(stdout,&lineLength,lineBuffer,"\"","\"\n");
  1780.     s[0]='|';
  1781.     s[1]=0;
  1782.     s=lineBuffer;
  1783.     for(i=0;i<strlen(s)-1;i++)if(isgraph(s[i]))s[i]=' ';
  1784. //    PrintfExit("%s\n",lineBuffer);
  1785.     PrintQuotedString(stdout,&lineLength,lineBuffer," ","\n");
  1786.     PrintfExit("");
  1787. }
  1788.  
  1789. char *ReadLine(char *lineBuffer,size_t bufferSize,FILE *stream,short flags)
  1790. /*  The Boolean global lineWasBlank is initialized to true in ReadAssignmentLine(),  */
  1791. /*  falsified (if appropriate) here, and returned by AssignmentLineWasBlank(). */
  1792. {
  1793.     char *s;
  1794.     static const char whiteSpace[]=" \t\n\r\v\f";
  1795.     extern int lineWasBlank;
  1796.     
  1797.     s=fgets(lineBuffer,bufferSize,stream);
  1798.     if(s==NULL){
  1799.         if(flags&assignNeedMore){
  1800.             if(PRINTF_EXIT)ParsingError(s,"premature end of stream");
  1801.             else return NULL;
  1802.         }else return NULL;
  1803.     }
  1804.     if(strlen(s)!=strspn(s,whiteSpace))lineWasBlank=FALSE;
  1805.     if(strlen(s)>=bufferSize-1 && s[strlen(s)-1]!=NEWLINE){
  1806.         if(PRINTF_EXIT){
  1807.             s+=strlen(s);
  1808.             ParsingError(s,"line exceeds buffer size");
  1809.         }else return NULL;
  1810.     }
  1811.     if(ECHO_FILE)printf("%s",s);
  1812.     return s;
  1813. }
  1814.  
  1815. char *NextToken(FILE *stream,char *lineBuffer,char *s,short flags)
  1816. /*
  1817. Skip past white space and comments to the beginning of the next token,
  1818. reading as many lines as necessary.
  1819. */
  1820. {
  1821.     do{
  1822.         s=NextTokenInThisOrNextLine(stream,lineBuffer,s,flags|assignNeedMore);
  1823.         if(s!=NULL || feof(stream))return s;
  1824.     }while(1);
  1825. }
  1826.  
  1827. char *NextTokenInThisOrNextLine(FILE *stream,char *lineBuffer,char *s,short flags)
  1828. /*
  1829. Skip past white space and comments to the beginning of the next token,
  1830. reading one line if necessary. 
  1831. */
  1832. {
  1833.     s=NextTokenInLine(stream,lineBuffer,s,flags);
  1834.     if(s!=NULL)return s;
  1835.     s=ReadLine(lineBuffer,BUFFER_SIZE,stream,flags);
  1836.     s=NextTokenInLine(stream,lineBuffer,s,flags);
  1837.     return s;
  1838. }
  1839.  
  1840. char *NextTokenInLine(FILE *stream,char *lineBuffer,char *s,short flags)
  1841. /*
  1842. Skip past white space and comments to the beginning of the next token. NextTokenInLine
  1843. will read in new lines only if they are continuations of the current line (i.e.
  1844. it ends in "\") or if new lines are needed to find the end of an unfinished
  1845. comment. Input from stream is buffered one line at a time in lineBuffer, and s
  1846. points to the next unparsed character in that buffer.
  1847. */
  1848. {
  1849.     static const char whiteSpace[]=" \t\n\r\v\f";
  1850.     char *sTemp;
  1851.  
  1852.     do{
  1853.         /* skip white space and comments */
  1854.         do {
  1855.             if(s==NULL || strlen(s)==0)goto endOfLine;
  1856.             s+=strspn(s,whiteSpace);
  1857.             if(strlen(s)==0)goto endOfLine;
  1858.             if(streq2(s,"/*")){
  1859.                 do{
  1860.                     sTemp=s;
  1861.                     s=strstr(s,"*/");
  1862.                     if(s!=NULL)break;
  1863.                     if(ECHO_COMMENTS)printf("%s",sTemp);
  1864.                     s=ReadLine(lineBuffer,BUFFER_SIZE,stream,flags|assignNeedMore);
  1865.                 } while(1);
  1866.                 s+=2;
  1867.                 if(ECHO_COMMENTS){
  1868.                     s[-1]=0;
  1869.                     printf("%s/",sTemp);
  1870.                 }
  1871.                 continue;
  1872.             }
  1873.             if(streq2(s,"//")){
  1874.                 if(ECHO_COMMENTS){
  1875.                     if(s[strlen(s)-1]==NEWLINE)s[strlen(s)-1]=0;
  1876.                     printf("%s",s);
  1877.                 }
  1878.                 goto endOfLine;
  1879.             }
  1880.             if(streq2(s,"\\" NL)){
  1881.                 if(ECHO_COMMENTS || ECHO_ASSIGNMENTS)printf(" \\\n");
  1882.                 s=ReadLine(lineBuffer,BUFFER_SIZE,stream,flags&~assignNeedMore);
  1883.                 continue;
  1884.             }
  1885.             break;
  1886.         } while(1);
  1887.         return s;    /* normal return */
  1888.     }while(1);
  1889. endOfLine:
  1890.     if((ECHO_ASSIGNMENTS || ECHO_COMMENTS) && s!=NULL)printf("\n");
  1891.     return NULL;
  1892. }
  1893.  
  1894. double strtodN(char *s,char **sPtr)
  1895. /*
  1896. Supplement standard C routine strtod() by also handling NAN and INF. Any specification
  1897. of the NAN's type (1 to 255) is ignored, whether in THINK C style, e.g. NANFF, in
  1898. MPW C style, e.g. Nan[255], or Metrowerks CodeWarrior C style, e.g. NAN(021).
  1899. */
  1900. {
  1901.     if(streq2(s,"NAN")||streq2(s,"NaN")||streq2(s,"Nan")||streq2(s,"nan")){
  1902.         s+=3;
  1903.         s+=strspn(s,"0123456789abcdefABCDEF[]()");
  1904.         *sPtr=s;
  1905.         return NAN;
  1906.     }
  1907.     if(strncmp(s,"INF",3)==0||strncmp(s,"Inf",3)==0||strncmp(s,"inf",3)==0){
  1908.         s+=3;
  1909.         *sPtr=s;
  1910.         return INF;
  1911.     }
  1912.     if(strncmp(s,"-INF",4)==0||strncmp(s,"-Inf",4)==0||strncmp(s,"-inf",4)==0){
  1913.         s+=4;
  1914.         *sPtr=s;
  1915.         return -INF;
  1916.     }
  1917.     return strtod(s,sPtr);
  1918. }
  1919.  
  1920. long strtolN(char *s,char **sPtr,short flags)
  1921. /* Supplement standard C routine strtol() by handling quoted char, e.g. 'e' */
  1922. {
  1923.     long j;
  1924.     
  1925.     if(*s!='\'') return strtol(s,sPtr,flags);
  1926.     s++;
  1927.     j=strtoc(s,&s);
  1928.     if(*s!='\''){
  1929.         if(PRINTF_EXIT)ParsingError(s,"expected \"'\"");
  1930.         else return 0;
  1931.     }
  1932.     *sPtr=s+1;
  1933.     return j;
  1934. }    
  1935.  
  1936. unsigned long strtoulN(char *s,char **sPtr,short flags)
  1937. /* Supplement standard C routine by handling quoted char, e.g. 'e' */
  1938. {
  1939.     unsigned long j;
  1940.     
  1941.     if(*s!='\'') return strtoul(s,sPtr,flags);
  1942.     s++;
  1943.     j=strtoc(s,&s);
  1944.     j &= 255L;        /* strip off any sign extension, since char was signed */
  1945.     if(*s!='\''){
  1946.         if(PRINTF_EXIT)ParsingError(s,"expected \"'\"");
  1947.         else return 0;
  1948.     }
  1949.     *sPtr=s+1;
  1950.     return j;
  1951. }    
  1952.  
  1953. char strtoc(char *s,char **sPtr)
  1954. /* Extract a character from a string, translating backslash escapes */
  1955. {
  1956.     char c;
  1957.     
  1958.     startAgain:
  1959.     if(*s!='\\'){
  1960.         if(*s==0){
  1961.             *sPtr=s;
  1962.             return -1;
  1963.         }
  1964.         *sPtr=s+1;
  1965.         return *s;
  1966.     }
  1967.     s++;
  1968.     switch(s++[0]){
  1969.     case 'n': c='\n'; break;
  1970.     case 'r': c='\r'; break;
  1971.     case 't': c='\t'; break;
  1972.     case 'b': c='\b'; break;
  1973.     case 'v': c='\v'; break;
  1974.     case 'f': c='\f'; break;
  1975.     case 'a': c='\a'; break;
  1976.     case 'x': c=strtol(s,&s,16); break;
  1977.     case '0': case '1':case '2': case '3':case '4': case '5':case '6': case '7':
  1978.         c=strtol(s-1,&s,8); break;
  1979.     case NEWLINE: s++; goto startAgain;
  1980.     default: c=s[-1]; break;
  1981.     }
  1982.     *sPtr=s;
  1983.     return c;
  1984. }
  1985.  
  1986. void PrintQuotedString(FILE *stream,short *lineLengthPtr,const char *s
  1987.     ,const char *openQuote,const char *closeQuote)
  1988. {
  1989.     *lineLengthPtr+=fprintf(stream,openQuote);
  1990.     do{
  1991.         for(;*s!=0 && *lineLengthPtr+1+(isprint(*s)?1:(isspace(*s)?2:4))<=MAX_LINELENGTH;s++){
  1992.             if(isprint(*s) && *s!='"' && *s!='\\')
  1993.                 *lineLengthPtr+=fprintf(stream,"%c",(PRINTF_INT)*s);
  1994.             else switch(*s){
  1995.             case '"': *lineLengthPtr+=fprintf(stream,"\\\""); break;
  1996.             case '\\': *lineLengthPtr+=fprintf(stream,"\\\\"); break;
  1997.             case '\n': *lineLengthPtr+=fprintf(stream,"\\n"); break;
  1998.             case '\t': *lineLengthPtr+=fprintf(stream,"\\t"); break;
  1999.             case '\b': *lineLengthPtr+=fprintf(stream,"\\b"); break;
  2000.             case '\r': *lineLengthPtr+=fprintf(stream,"\\r"); break;
  2001.             case '\v': *lineLengthPtr+=fprintf(stream,"\\v"); break;
  2002.             case '\f': *lineLengthPtr+=fprintf(stream,"\\f"); break;
  2003.             case '\312': *lineLengthPtr+=fprintf(stream,"\312"); break;    // option-space
  2004.             default: *lineLengthPtr+=fprintf(stream,"\\%03lo"
  2005.                 ,(unsigned long)*(unsigned char *)s); break;
  2006.             }
  2007.         }
  2008.         if(*s!=0){
  2009.             fprintf(stream,"\"" NL);
  2010.             *lineLengthPtr=0;
  2011.             *lineLengthPtr+=fprintf(stream,"    \"");
  2012.         }
  2013.     }while(*s!=0);
  2014.     *lineLengthPtr+=fprintf(stream,closeQuote);
  2015. }
  2016.  
  2017. #if 0
  2018.     /*  A longer, Macintosh-savvy, version of this routine, PrintfExit.c, */
  2019.     /*  is part of the VideoToolbox. */
  2020.     int PrintfExit(const char *format,...)
  2021.     {
  2022.         va_list args;
  2023.         int i;
  2024.       
  2025.         va_start(args,format);
  2026.         i=vfprintf(stdout,format,args);
  2027.         va_end(args);
  2028.         exit(1);
  2029.     }
  2030. #endif
  2031.